package com.wxw.BaseLibrary.tool;

/**
 * Created by david on 14-3-12.
 */
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.StringTokenizer;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.text.format.Time;

public class ToolsDate {
    public static int DAY = GregorianCalendar.DAY_OF_MONTH;
    public static int MONTH = GregorianCalendar.MONTH;
    public static int YEAR = GregorianCalendar.YEAR;
    /**
     * 以"yyyyMMddHHmmss"为默认格式，返回即时时间
     * @return 该格式的即时时间 如"20060401213353"。
     */
    public static String getDate()
    {
        return getDate("yyyyMMddHHmmss");
    }
    /**
     * 以"yyyy-MM-dd HH:mm:ss"为默认格式，返回即时时间
     * @return 该格式的即时时间 如"2006-04-01 21:33:53"。
     */
    public static String getDateLine()
    {
        return getDate("yyyy-MM-dd HH:mm:ss");
    }

    public static String getDateLine(int part, int add) {
        return getDate(part, add, "yyyy-MM-dd HH:mm:ss");
    }
    /**
     * 输入需要的时间格式，得到该格式的即时时间 如参数为"yyyyMMddHHmmss",则返回"20060401235959"。
     * 如参数为"yyyy-M-d H:m:s"，则返回"2006-4-1 21:33:53"。
     * 如参数为"zzzz,yyyy年MMM dd日 a hh:mm:ss  EEE" 则返回"中国标准时间,2004年四月 04日 上午 01:09:45  星期日"
     * 注意：y为年，M为月，d为日。H为小时(24小时)，h为小时（12小时）m为分钟，s为秒。注意大小写。
     * 		zzzz为时区，EEE为星期，MMMM为月份(大写)，a为上下午。
     * @param timeFormat 输入需要的时间格式 如参数为"yyyy-MM-dd HH:mm:ss
     * @return 该格式的即时时间 如"2006-04-01 21:33:53"。
     */
    public static String getDate(String timeFormat) {
        return getDate(DAY, 0, timeFormat);
    }

    public static String getDate(int part, int add, String timeFormat) {
        try {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(timeFormat);
            String newDate = simpleDateFormat.format(getDate(part, add));
            return newDate;
        } catch (Exception e) {
            System.out.println("得到该格式的时间错误" );
            return "";
        }
    }

    public static Date getDate(int part, int add) {
        try{
            Date date = new Date(System.currentTimeMillis());
            GregorianCalendar gregorianCalendar = new GregorianCalendar();
            gregorianCalendar.setTime(date);
            gregorianCalendar.add(part, add);
            return gregorianCalendar.getTime();
        } catch (Exception e) {
            return new Date(System.currentTimeMillis());
        }
    }

    public static Time getTime(){
        try {
            Time time = new Time();
            time.setToNow();
            return time;
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
            return null;
        }
    }

    /**
     * 输入时间字符串，原时间字符串格式，和需要得到的时间字符串格式,得到需要格式的时间字符串。
     * 注意：y为年，M为月，d为日。H为小时(24小时)，h为小时（12小时）m为分钟，s为秒。注意大小写。
     * 		 zzzz为时区，EEE为星期，MMMM为月份(大写)，a为上下午。
     * @param datetime   需要转换格式的时间字符 如2006040123595。
     * @param oldFormat  原时间字符串格式 如"yyyyMMddHHmmss"。注意，该格式必须与给定时间字符串的格式一致。
     * @param newFormat  原时间字符串格式 如"yyyy-M-d H:m:s"。
     *
     * @return 需要格式的时间字符串 如：2006-04-01 23:59:59
     */
    public static String formatDate(String datetime, String oldFormat, String newFormat) {
        String dateStr = "";
        if (datetime == null || oldFormat == null || newFormat == null) {
            System.out.println("你输入的参数错误，请检查datetime,oldFormat,newFormat参数" );
            return null;
        }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(newFormat);
        Calendar calendar = getCalendar(datetime, oldFormat);
        if (calendar == null) {
            System.out.println("初始化时间错误");
            return null;
        }
        Date newDate = calendar.getTime();
        dateStr = simpleDateFormat.format(newDate);

        return dateStr;

    }
    /**
     * 得到给定时间前（后）N小时的时间字符串。
     * @param datetime  给定的时间字符串，如"20060401235959"。
     * @param oldFormat 给定的时间字符串格式，如"yyyyMMddHHmmss"
     * @param newFormat 新时间的字符串格式，如yyyyMMdd。
     * @param difftime  需要偏移的时间，精确到小时，如24（前）或-24（后）。
     * @return 得到给定时间前（后）N小时的时间字符串，20060331
     */
    public static String getBeforeTime(String datetime, String oldFormat,String newFormat, int difftime)
    {
        String newTime = null;
        if (datetime == null || oldFormat == null) {
            System.out.println("你输入的参数错误，请检查datetime,oldFormat,newFormat参数");
            return null;
        }
        //得到给定时间的Calendar
        Calendar calendar = getCalendar(datetime, oldFormat);
        if(calendar==null){
            System.out.println("初始化时间错误");
            return null;
        }
        //得到给定时间的，精确到小时(24小时)。
        calendar.add(Calendar.HOUR_OF_DAY,-difftime);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(newFormat);
        newTime = simpleDateFormat.format(calendar.getTime());
        return newTime;


    }
    /**
     * 得到给定的日期是星期几
     * @param datetime 给定的时间字符串，如"20060401"。
     * @param dateFormat 给定的时间字符串格式，如"yyyyMMdd"
     * @return 返回该日期是星期几 如"星期六"
     */
    public static String getWeekOfDay(String datetime,String dateFormat){
        String weekStr = "";
        if (datetime == null||dateFormat==null){
            System.out.println("你输入的参数错误，请检查datetime(20060401),dateForma(yyyyMMdd)参数");
            return null;
        }
        weekStr = formatDate(datetime,dateFormat,"EEE");
        return weekStr;
    }

    public static int getWeekDayIndex() {
        return getWeekDayIndex(getDate(), "yyyyMMddHHmmss");
    }

    public static int getWeekDayIndex(String datetime, String dateFormat) {
        SimpleDateFormat format = new SimpleDateFormat(dateFormat);
        Calendar c = Calendar.getInstance();
        try {
            c.setTime(format.parse(datetime));
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return c.get(Calendar.DAY_OF_WEEK)-1;
    }

    public static Calendar getCalendar(String datetime, String dateFormat) {
        Calendar calendar = null;
        if (datetime == null || dateFormat == null) {
            return null;
        }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat);
        // 从给定时间字符串的第一位开始分析,返回Date类型
        Date newdate = simpleDateFormat.parse(datetime,
                new ParsePosition(0));
        if (newdate == null) {
            return null;
        }
        calendar = Calendar.getInstance();
        calendar.clear();
        calendar.setTime(newdate);
        return calendar;

    }
    public static String dealNull(String str)
    {
        String returnstr = null;
        if(str == null) {
            returnstr = "";
        } else {
            returnstr = str;
        }
        return returnstr;
    }
    public static Object dealNull(Object obj)
    {
        Object returnstr = null;
        if(obj == null) {
            returnstr = "";
        } else {
            returnstr = obj;
        }
        return returnstr;
    }
    public static boolean isEmpty(String str)
    {
        boolean ret = false;
        if("".equals(trim(str))) {
            ret = true;
        }
        return ret;
    }
    /**
     * 将给定的字符串做去空处理。
     * 如果给定字符串为null、"null"、"Null"等，返回空字符串。
     * 如果给定字符串为" str"、"str "或" str "，则返回"str";
     * @param str 需要转换的字符串 如null,"null"。
     * @return 处理后的字符串 如""。
     */
    public static String trim(String str){
        if(str==null){
            return "";
        }
        //比较str是否等于"null",忽略大小写。
        if("null".equalsIgnoreCase(str.trim())){
            return "";
        }else{
            return str.trim();
        }
    }
    /**
     * 把给定的可解析成整数的字符串转换成整数,如果为0长度的字符串，则返回0。
     * @param str 需要转换成格式的字符串，如"122  "。
     * @return 得到相对应的整数 如122。
     * @throws Exception 如果给定字符串不是可解析的整数,如果发生异常，则返回0。
     */
    public static int parseInt(String str){
        String strTemp = "";
        int ret = 0;

        try {
            if(str==null){
                System.out.println("你给定的参数不可以为null");
                return 0;
            }else{
                strTemp = ToolsDate.trim(str);
                if("".equals(strTemp)){
                    System.out.println("你给定的参数不可以为空字符串");
                    return 0;
                }
            }
            ret = Integer.parseInt(strTemp);
            return ret;
        } catch (Exception e) {
            System.out.println("你给定的参数，不能转换为数字");
            return 0;
        }

    }

    /**
     * 判断该字符串是否全部由可解析成数字格式的字符组成。
     * @param validString 给定字符串
     * @return boolean
     */
    public static boolean isNumber(String validString)
    {
        byte tempbyte[] = validString.getBytes();
        for(int i = 0; i < validString.length(); i++){
            if(tempbyte[i] < 48 || tempbyte[i] > 57){
                return false;
            }
        }
        return true;
    }
    /**
     * 判断给定字符串是否全部由可解析成Char型字符的字符组成。
     * @param validString
     * @return boolean
     */
    public static boolean isChar(String validString)
    {
        byte tempbyte[] = validString.getBytes();
        for(int i = 0; i < validString.length(); i++){
            if(tempbyte[i] < 48 || (tempbyte[i] > 57) & (tempbyte[i] < 65) || tempbyte[i] > 122 || (tempbyte[i] > 90) & (tempbyte[i] < 95) || (tempbyte[i] > 95) & (tempbyte[i] < 97)){
                return false;
            }
        }
        return true;
    }
    /**
     * 判断给定字符串是否全部由可解析成小写字母的字符组成。
     * @param validString
     * @return boolean
     */
    public static boolean isLetter(String validString)
    {
        byte tempbyte[] = validString.getBytes();
        for(int i = 0; i < validString.length(); i++){
            if(tempbyte[i] < 65 || tempbyte[i] > 122 || (tempbyte[i] > 90) & (tempbyte[i] < 97)){
                return false;
            }
        }
        return true;
    }
    /**
     * 将给定字符串通过给定字符分割，将分割后的子字符串通过字符串数组形式返回。
     * @param str 给定字符串 如：asadafagah。
     * @param delim 给定的分割字符 如a。
     * @return 字符串数组 如：{s,d,f,g,h}
     * @throws Exception 如果给定字符串或分割字符为null或0字节字符串，则返回null。
     */
    public static String[] getStrData(String str,String delim){
        String[] data = null;
        if(str==null|| "".equals(str)){
            return null;
        }
        if(delim==null|| "".equals(delim)){
            return null;

        }
        StringTokenizer st = new StringTokenizer(str,delim);
        int amount = st.countTokens();
        data = new String[amount];
        for(int i=0;i<amount;i++){
            data[i] = st.nextToken();
        }
        return data;
    }

    /**
     * 将给定的字符串截取，得到指定长度的字符串(解决了对中文字符截取一半的问题)。
     * @param sourceString 给定的源字符串   如“伟大的领袖毛主席”
     * @param subLength     截取的长度          如“10”
     * @return						 截取后的字符串  如“伟大的领袖...”
     */
    public static String fmtString(String sourceString, int subLength) {
        String newStr = ToolsDate.trim(sourceString);
        byte[] data = newStr.getBytes();
        if (data.length <= subLength){
            return newStr;
        }
        byte[] strTemp = new byte[subLength];
        System.arraycopy(data, 0, strTemp, 0, subLength);
        data = strTemp;
        int count = 0;
        for (int i = 0; i < data.length && data[data.length - 1 - i] < 0; i++){
            count++;
        }

        if(count%2==1){
            byte tmp2[] = new byte[data.length - 1];
            System.arraycopy(data, 0, tmp2, 0, data.length - 1);
            data = tmp2;
        }
        String retString = new String(data);
        return retString;
    }
    /**
     *
     * @param l 传入毫秒数
     * @return	返回转换后的毫秒数信息
     */
    public static String getLongDate(long l){
        SimpleDateFormat format = new SimpleDateFormat(
                "yyyy-MM-dd HH:mm:ss");

        return format.format(l);
    }
    /**
     * 检测网络连接是否可用
     * @param ctx
     * @return true 可用; false 不可用
     */
    public static boolean isNetworkAvailable(Context ctx) {
        ConnectivityManager cm =
                (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
        if(cm == null) {
            return false;
        }
        NetworkInfo[] netinfo = cm.getAllNetworkInfo();
        if(netinfo == null) {
            return false;
        }
        for (int i = 0; i < netinfo.length; i++) {
            if(netinfo[i].isConnected()) {
                return true;
            }
        }
        return false;
    }
}
